// ==========================================================
// FreeImage 3 .NET wrapper
// Original FreeImage 3 functions and .NET compatible derived functions
//
// Design and implementation by
// - Jean-Philippe Goerke (jpgoerke@users.sourceforge.net)
// - Carsten Klein (cklein05@users.sourceforge.net)
//
// Contributors:
// - David Boland (davidboland@vodafone.ie)
//
// Main reference : MSDN Knowlede Base
//
// This file is part of FreeImage 3
//
// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
// THIS DISCLAIMER.
//
// Use at your own risk!
// ==========================================================

// ==========================================================
// CVS
// $Revision: 1.6 $
// $Date: 2009/09/15 11:49:24 $
// $Id: MetadataModels.cs,v 1.6 2009/09/15 11:49:24 cklein05 Exp $
// ==========================================================

using System;
using System.Xml;
using System.IO;
using System.Text;

namespace FreeImageAPI.Metadata
{
	/// <summary>
	/// Represents a collection of all tags contained in the metadata model
	/// <see cref="FREE_IMAGE_MDMODEL.FIMD_ANIMATION"/>.
	/// </summary>
	public class MDM_ANIMATION : MetadataModel
	{
		/// <summary>
		/// Initializes a new instance of this class.
		/// </summary>
		/// <param name="dib">Handle to a FreeImage bitmap.</param>
		public MDM_ANIMATION(FIBITMAP dib) : base(dib) { }

		/// <summary>
		/// Retrieves the datamodel that this instance represents.
		/// </summary>
		public override FREE_IMAGE_MDMODEL Model
		{
			get { return FREE_IMAGE_MDMODEL.FIMD_ANIMATION; }
		}

		/// <summary>
		/// Gets or sets the width of the entire canvas area, that each page is displayed in.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? LogicalWidth
		{
			get
			{
				return GetTagValue<ushort>("LogicalWidth");
			}
			set
			{
				SetTagValue("LogicalWidth", value);
			}
		}

		/// <summary>
		/// Gets or sets the height of the entire canvas area, that each page is displayed in.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? LogicalHeight
		{
			get
			{
				return GetTagValue<ushort>("LogicalHeight");
			}
			set
			{
				SetTagValue("LogicalHeight", value);
			}
		}

		/// <summary>
		/// Gets or sets the global palette of the GIF image.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public Palette GlobalPalette
		{
			get
			{
				MetadataTag mdtag = GetTag("GlobalPalette");
				return (mdtag == null) ? null : new Palette(mdtag);
			}
			set
			{
				SetTagValue("GlobalPalette", value?.Data);
			}
		}

		/// <summary>
		/// Gets or sets the number of replays for the animation.
		/// Use 0 (zero) to specify an infinte number of replays.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public uint? LoopCount
		{
			get
			{
				return GetTagValue<uint>("Loop");
			}
			set
			{
				SetTagValue("Loop", value);
			}
		}

		/// <summary>
		/// Gets or sets the horizontal offset within the logical canvas area, this frame is to be displayed at.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? FrameLeft
		{
			get
			{
				return GetTagValue<ushort>("FrameLeft");
			}
			set
			{
				SetTagValue("FrameLeft", value);
			}
		}

		/// <summary>
		/// Gets or sets the vertical offset within the logical canvas area, this frame is to be displayed at.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? FrameTop
		{
			get
			{
				return GetTagValue<ushort>("FrameTop");
			}
			set
			{
				SetTagValue("FrameTop", value);
			}
		}

		/// <summary>
		/// Gets or sets a flag to supress saving the dib's attached palette
		/// (making it use the global palette). The local palette is the palette used by a page.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public bool? NoLocalPalette
		{
			get
			{
				byte? useGlobalPalette = GetTagValue<byte>("NoLocalPalette");
				return useGlobalPalette.HasValue ? (useGlobalPalette.Value != 0) : default(bool?);
			}
			set
			{
				byte? val = null;
				if (value.HasValue)
				{
					val = (byte)(value.Value ? 1 : 0);
				}
				SetTagValue("NoLocalPalette", val);
			}
		}

		/// <summary>
		/// Gets or sets a value indicating whether the image is interlaced.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public bool? Interlaced
		{
			get
			{
				byte? useGlobalPalette = GetTagValue<byte>("Interlaced");
				return useGlobalPalette.HasValue ? (useGlobalPalette.Value != 0) : default(bool?);
			}
			set
			{
				byte? val = null;
				if (value.HasValue)
				{
					val = (byte)(value.Value ? 1 : 0);
				}
				SetTagValue("Interlaced", val);
			}
		}

		/// <summary>
		/// Gets or sets the amout of time in milliseconds this frame is to be displayed.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public uint? FrameTime
		{
			get
			{
				return GetTagValue<uint>("FrameTime");
			}
			set
			{
				SetTagValue("FrameTime", value);
			}
		}

		/// <summary>
		/// Gets or sets this frame's disposal method. Generally, this method defines, how to
		/// remove or replace a frame when the next frame has to be drawn.<para/>
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public DisposalMethodType? DisposalMethod
		{
			get
			{
				return GetTagValue<DisposalMethodType>("DisposalMethod");
			}
			set
			{
				SetTagValue("DisposalMethod", value);
			}
		}
	}

	/// <summary>
	/// Represents a collection of all tags contained in the metadata model
	/// <see cref="FREE_IMAGE_MDMODEL.FIMD_COMMENTS"/>.
	/// </summary>
	public class MDM_COMMENTS : MetadataModel
	{
		/// <summary>
		/// Initializes a new instance of this class.
		/// </summary>
		/// <param name="dib">Handle to a FreeImage bitmap.</param>
		public MDM_COMMENTS(FIBITMAP dib) : base(dib) { }

		/// <summary>
		/// Retrieves the datamodel that this instance represents.
		/// </summary>
		public override FREE_IMAGE_MDMODEL Model
		{
			get { return FREE_IMAGE_MDMODEL.FIMD_COMMENTS; }
		}

		/// <summary>
		/// Gets or sets the comment of the image.
		/// Supported formats are JPEG, PNG and GIF.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Comment
		{
			get
			{
				return GetTagText("Comment");
			}
			set
			{
				SetTagValue("Comment", value);
			}
		}
	}

	/// <summary>
	/// Represents a collection of all tags contained in the metadata model
	/// <see cref="FREE_IMAGE_MDMODEL.FIMD_CUSTOM"/>.
	/// </summary>
	public class MDM_CUSTOM : MetadataModel
	{
		/// <summary>
		/// Initializes a new instance of this class.
		/// </summary>
		/// <param name="dib">Handle to a FreeImage bitmap.</param>
		public MDM_CUSTOM(FIBITMAP dib) : base(dib) { }

		/// <summary>
		/// Retrieves the datamodel that this instance represents.
		/// </summary>
		public override FREE_IMAGE_MDMODEL Model
		{
			get { return FREE_IMAGE_MDMODEL.FIMD_CUSTOM; }
		}
	}

	/// <summary>
	/// Represents a collection of all tags contained in the metadata model
	/// <see cref="FREE_IMAGE_MDMODEL.FIMD_EXIF_EXIF"/>.
	/// </summary>
	public class MDM_EXIF_EXIF : MetadataModel
	{
		/// <summary>
		/// Initializes a new instance of this class.
		/// </summary>
		/// <param name="dib">Handle to a FreeImage bitmap.</param>
		public MDM_EXIF_EXIF(FIBITMAP dib) : base(dib) { }

		/// <summary>
		/// Retrieves the datamodel that this instance represents.
		/// </summary>
		public override FREE_IMAGE_MDMODEL Model
		{
			get { return FREE_IMAGE_MDMODEL.FIMD_EXIF_EXIF; }
		}

		/// <summary>
		/// Gets or sets the version of this standard supported.
		/// Constant length or 4.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte[] ExifVersion
		{
			get
			{
				return GetTagArray<byte>("ExifVersion");
			}
			set
			{
				FreeImage.Resize(ref value, 4);
				SetTagValueUndefined("ExifVersion", value);
			}
		}

		/// <summary>
		/// Gets or sets the Flashpix format version supported by a FPXR file.
		/// Constant length or 4.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte[] FlashpixVersion
		{
			get
			{
				return GetTagArray<byte>("FlashpixVersion");
			}
			set
			{
				FreeImage.Resize(ref value, 4);
				SetTagValueUndefined("FlashpixVersion", value);
			}
		}

		/// <summary>
		/// Gets or sets the color space information tag.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are defined:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>1</term>
		///			<description>SRgb (default)</description>
		///		</item>
		///		<item>
		///			<term>0xFFFF</term>
		///			<description>uncalibrated</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? ColorSpace
		{
			get
			{
				return GetTagValue<ushort>("ColorSpace");
			}
			set
			{
				SetTagValue("ColorSpace", value);
			}
		}

		/// <summary>
		/// Gets or sets the valid width of a compressed image.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public uint? PixelXDimension
		{
			get
			{
				return GetUInt32Value("PixelXDimension");
			}
			set
			{
				RemoveTag("PixelXDimension");
				if (value.HasValue)
				{
					SetTagValue("PixelXDimension", value.Value);
				}
			}
		}

		/// <summary>
		/// Gets or sets the valid height of a compressed image.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public uint? PixelYDimension
		{
			get
			{
				return GetUInt32Value("PixelYDimension");
			}
			set
			{
				RemoveTag("PixelYDimension");
				if (value.HasValue)
				{
					SetTagValue("PixelYDimension", value.Value);
				}
			}
		}

		/// <summary>
		/// Gets or sets components configuration. See remarks for further information.
		/// Constant length of 4.
		/// </summary>
		/// <remarks>
		/// The channels of each component are arranged in order from the 1st component to the 4th.
		/// For uncompressed data the data arrangement is given in the PhotometricInterpretation tag.
		/// However, since PhotometricInterpretation can only express the order of Y,Cb and Cr,
		/// this tag is provided for cases when compressed data uses components other than Y, Cb,
		/// and Cr and to enable support of other sequences.<para/>
		/// Default = 4 5 6 0 (if RGB uncompressed)<para/>
		/// The following values are defined:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>does not exist</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>Y</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>Cb</description>
		///		</item>
		///		<item>
		///			<term>3</term>
		///			<description>Cr</description>
		///		</item>
		///		<item>
		///			<term>4</term>
		///			<description>R</description>
		///		</item>
		///		<item>
		///			<term>5</term>
		///			<description>R</description>
		///		</item>
		///		<item>
		///			<term>6</term>
		///			<description>R</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte[] ComponentsConfiguration
		{
			get
			{
				return GetTagArray<byte>("ComponentsConfiguration");
			}
			set
			{
				FreeImage.Resize(ref value, 4);
				SetTagValueUndefined("ComponentsConfiguration", value);
			}
		}

		/// <summary>
		/// Gets or sets compression mode used for a compressed image is indicated
		/// in unit bits per pixel.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? CompressedBitsPerPixel
		{
			get
			{
				return GetTagValue<FIURational>("CompressedBitsPerPixel");
			}
			set
			{
				SetTagValue("CompressedBitsPerPixel", value);
			}
		}

		/// <summary>
		/// Gets or sets a tag for manufacturers of Exif writers to record any desired information.
		/// The contents are up to the manufacturer, but this tag should not be used for any other
		/// than its intended purpose.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte[] MakerNote
		{
			get
			{
				return GetTagArray<byte>("FlashpixVersion");
			}
			set
			{
				SetTagValueUndefined("FlashpixVersion", value);
			}
		}

		/// <summary>
		/// Gets or sets a tag for Exif users to write keywords or comments on the image besides
		/// those in ImageDescription, and without the character code limitations of the ImageDescription tag.
		/// Minimum length of 8. See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The character code used in the UserComment tag is identified based on an ID code in a fixed 8-byte
		/// area at the start of the tag data area. The unused portion of the area is padded with NULL.
		/// The ID code for the UserComment area may be a Defined code such as JIS or ASCII, or may be Undefined.
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte[] UserComment
		{
			get
			{
				return GetTagArray<byte>("UserComment");
			}
			set
			{
				FreeImage.Resize(ref value, 8, int.MaxValue);
				SetTagValueUndefined("UserComment", value);
			}
		}

		/// <summary>
		/// Gets or sets the name of an audio file related to the image data.
		/// The format is 8.3.
		/// Constant length of 12
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string RelatedSoundFile
		{
			get
			{
				string text = GetTagText("RelatedSoundFile");
				if (!string.IsNullOrEmpty(text))
				{
					text = text.Substring(0, text.Length - 1);
				}
				return text;
			}
			set
			{
				if (value != null)
				{
					FreeImage.Resize(ref value, 12);
					value += '\0';
				}
				SetTagValue("RelatedSoundFile", value);
			}
		}

		/// <summary>
		/// Gets or sets the date and time when the original image data was generated.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public DateTime? DateTimeOriginal
		{
			get
			{
				DateTime? result = null;
				string text = GetTagText("DateTimeOriginal");
				if (text != null)
				{
					try
					{
						result = System.DateTime.ParseExact(text, "yyyy:MM:dd HH:mm:ss\0", null);
					}
					catch
					{
					}
				}
				return result;
			}
			set
			{
				string val = null;
				if (value.HasValue)
				{
					try
					{
						val = value.Value.ToString("yyyy:MM:dd HH:mm:ss\0");
					}
					catch
					{
					}
				}
				SetTagValue("DateTimeOriginal", val);
			}
		}

		/// <summary>
		/// Gets or sets the date and time when the image was stored as digital data.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public DateTime? DateTimeDigitized
		{
			get
			{
				DateTime? result = null;
				string text = GetTagText("DateTimeDigitized");
				if (text != null)
				{
					try
					{
						result = DateTime.ParseExact(text, "yyyy:MM:dd HH:mm:ss\0", null);
					}
					catch
					{
					}
				}
				return result;
			}
			set
			{
				string val = null;
				if (value.HasValue)
				{
					try
					{
						val = value.Value.ToString("yyyy:MM:dd HH:mm:ss\0");
					}
					catch
					{
					}
				}
				SetTagValue("DateTimeDigitized", val);
			}
		}

		/// <summary>
		/// Gets or sets a tag used to record fractions of seconds for the DateTime tag.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string SubsecTime
		{
			get
			{
				string text = GetTagText("SubsecTime");
				if (!string.IsNullOrEmpty(text))
				{
					text = text.Substring(0, text.Length - 1);
				}
				return text;
			}
			set
			{
				if (value != null)
				{
					value += '\0';
				}
				SetTagValue("SubsecTime", value);
			}
		}

		/// <summary>
		/// Gets or sets a tag used to record fractions of seconds for the DateTimeOriginal tag.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string SubsecTimeOriginal
		{
			get
			{
				string text = GetTagText("SubsecTimeOriginal");
				if (!string.IsNullOrEmpty(text))
				{
					text = text.Substring(0, text.Length - 1);
				}
				return text;
			}
			set
			{
				if (value != null)
				{
					value += '\0';
				}
				SetTagValue("SubsecTimeOriginal", value);
			}
		}

		/// <summary>
		/// Gets or sets a tag used to record fractions of seconds for the DateTimeDigitized tag.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string SubsecTimeDigitized
		{
			get
			{
				string text = GetTagText("SubsecTimeDigitized");
				if (!string.IsNullOrEmpty(text))
				{
					text = text.Substring(0, text.Length - 1);
				}
				return text;
			}
			set
			{
				if (value != null)
				{
					value += '\0';
				}
				SetTagValue("SubsecTimeDigitized", value);
			}
		}

		/// <summary>
		/// Gets or the exposure time, given in seconds (sec).
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? ExposureTime
		{
			get
			{
				return GetTagValue<FIURational>("ExposureTime");
			}
			set
			{
				SetTagValue("ExposureTime", value);
			}
		}

		/// <summary>
		/// Gets or the F number.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? FNumber
		{
			get
			{
				return GetTagValue<FIURational>("FNumber");
			}
			set
			{
				SetTagValue("FNumber", value);
			}
		}

		/// <summary>
		/// Gets or sets the class of the program used by the camera to set exposure when the
		/// picture is taken.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are defined:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>not defined</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>manual</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>normal program</description>
		///		</item>
		///		<item>
		///			<term>3</term>
		///			<description>aperture priority</description>
		///		</item>
		///		<item>
		///			<term>4</term>
		///			<description>shutter priority</description>
		///		</item>
		///		<item>
		///			<term>5</term>
		///			<description>create program</description>
		///		</item>
		///		<item>
		///			<term>6</term>
		///			<description>action program</description>
		///		</item>
		///		<item>
		///			<term>7</term>
		///			<description>portrait mode</description>
		///		</item>
		///		<item>
		///			<term>8</term>
		///			<description>landscape mode</description>
		///		</item>
		///		<item>
		///			<term>others</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? ExposureProgram
		{
			get
			{
				return GetTagValue<ushort>("ExposureProgram");
			}
			set
			{
				SetTagValue("ExposureProgram", value);
			}
		}

		/// <summary>
		/// Gets or sets the spectral sensitivity of each channel of the camera used.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string SpectralSensitivity
		{
			get
			{
				string text = GetTagText("SpectralSensitivity");
				if (!string.IsNullOrEmpty(text))
				{
					text = text.Substring(0, text.Length - 1);
				}
				return text;
			}
			set
			{
				if (value != null)
				{
					value += '\0';
				}
				SetTagValue("SpectralSensitivity", value);
			}
		}

		/// <summary>
		/// Gets or sets the the ISO Speed and ISO Latitude of the camera or input device as
		/// specified in ISO 12232.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort[] ISOSpeedRatings
		{
			get
			{
				return GetTagArray<ushort>("ISOSpeedRatings");
			}
			set
			{
				SetTagValue("ISOSpeedRatings", value);
			}
		}

		/// <summary>
		/// Gets or sets the Opto-Electric Conversion Function (OECF) specified in ISO 14524.
		/// OECF is the relationship between the camera optical input and the image values.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte[] OECF
		{
			get
			{
				return GetTagArray<byte>("OECF");
			}
			set
			{
				SetTagValueUndefined("OECF", value);
			}
		}

		/// <summary>
		/// Gets or sets the shutter speed. The unit is the APEX (Additive System of Photographic Exposure).
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIRational? ShutterSpeedValue
		{
			get
			{
				return GetTagValue<FIRational>("ShutterSpeedValue");
			}
			set
			{
				SetTagValue("ShutterSpeedValue", value);
			}
		}

		/// <summary>
		/// Gets or sets the lens aperture. The unit is the APEX value.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? ApertureValue
		{
			get
			{
				return GetTagValue<FIURational>("ApertureValue");
			}
			set
			{
				SetTagValue("ApertureValue", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of brightness. The unit is the APEX value.
		/// Ordinarily it is given in the range of -99.99 to 99.99.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIRational? BrightnessValue
		{
			get
			{
				return GetTagValue<FIRational>("BrightnessValue");
			}
			set
			{
				SetTagValue("BrightnessValue", value);
			}
		}

		/// <summary>
		/// Gets or sets the exposure bias. The unit is the APEX value.
		/// Ordinarily it is given in the range of -99.99 to 99.99.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIRational? ExposureBiasValue
		{
			get
			{
				return GetTagValue<FIRational>("ExposureBiasValue");
			}
			set
			{
				SetTagValue("ExposureBiasValue", value);
			}
		}

		/// <summary>
		/// Gets or sets the smallest F number of the lens. The unit is the APEX value.
		/// Ordinarily it is given in the range of 00.00 to 99.99,
		/// but it is not limited to this range.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? MaxApertureValue
		{
			get
			{
				return GetTagValue<FIURational>("MaxApertureValue");
			}
			set
			{
				SetTagValue("MaxApertureValue", value);
			}
		}

		/// <summary>
		/// Gets or sets distance to the subject, given in meters.
		/// Note that if the numerator of the recorded value is FFFFFFFF, infinity shall be indicated;
		/// and if the numerator is 0, distance unknown shall be indicated.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? SubjectDistance
		{
			get
			{
				return GetTagValue<FIURational>("SubjectDistance");
			}
			set
			{
				SetTagValue("SubjectDistance", value);
			}
		}

		/// <summary>
		/// Gets or sets the metering mode. See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are defined:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>unknown</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>average</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>center-weighted-average</description>
		///		</item>
		///		<item>
		///			<term>3</term>
		///			<description>spot</description>
		///		</item>
		///		<item>
		///			<term>4</term>
		///			<description>multi-spot</description>
		///		</item>
		///		<item>
		///			<term>5</term>
		///			<description>pattern</description>
		///		</item>
		///		<item>
		///			<term>6</term>
		///			<description>partial</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		///		<item>
		///			<term>255</term>
		///			<description>other</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? MeteringMode
		{
			get
			{
				return GetTagValue<ushort>("MeteringMode");
			}
			set
			{
				SetTagValue("MeteringMode", value);
			}
		}

		/// <summary>
		/// Gets or sets the kind of light source.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are defined:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>unknown</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>daylight</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>fluorescent</description>
		///		</item>
		///		<item>
		///			<term>3</term>
		///			<description>tungsten</description>
		///		</item>
		///		<item>
		///			<term>4</term>
		///			<description>flash</description>
		///		</item>
		///		<item>
		///			<term>9</term>
		///			<description>fine weather</description>
		///		</item>
		///		<item>
		///			<term>10</term>
		///			<description>cloudy weather</description>
		///		</item>
		///		<item>
		///			<term>11</term>
		///			<description>shade</description>
		///		</item>
		///		<item>
		///			<term>12</term>
		///			<description>daylight fluorecent (D 5700 - 7100K)</description>
		///		</item>
		///		<item>
		///			<term>13</term>
		///			<description>day white fluorescent (N 4600 - 5400K)</description>
		///		</item>
		///		<item>
		///			<term>14</term>
		///			<description>cool white fluorescent (W 3900 - 4500K)</description>
		///		</item>
		///		<item>
		///			<term>15</term>
		///			<description>white fluorescent (WW 3200 - 3700K)</description>
		///		</item>
		///		<item>
		///			<term>17</term>
		///			<description>standard light A</description>
		///		</item>
		///		<item>
		///			<term>18</term>
		///			<description>standard light B</description>
		///		</item>
		///		<item>
		///			<term>19</term>
		///			<description>standard light C</description>
		///		</item>
		///		<item>
		///			<term>20</term>
		///			<description>D55</description>
		///		</item>
		///		<item>
		///			<term>21</term>
		///			<description>D65</description>
		///		</item>
		///		<item>
		///			<term>22</term>
		///			<description>D75</description>
		///		</item>
		///		<item>
		///			<term>23</term>
		///			<description>D50</description>
		///		</item>
		///		<item>
		///			<term>24</term>
		///			<description>ISO studio tungsten</description>
		///		</item>
		///		<item>
		///			<term>255</term>
		///			<description>other light source</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? LightSource
		{
			get
			{
				return GetTagValue<ushort>("LightSource");
			}
			set
			{
				SetTagValue("LightSource", value);
			}
		}

		/// <summary>
		/// Gets or sets a value indicating the status of flash when the image was shot.
		/// Bit 0 indicates the flash firing status, bits 1 and 2 indicate the flash return
		/// status, bits 3 and 4 indicate the flash mode, bit 5 indicates whether the flash
		/// function is present, and bit 6 indicates "red eye" mode.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? Flash
		{
			get
			{
				return GetTagValue<ushort>("Flash");
			}
			set
			{
				SetTagValue("Flash", value);
			}
		}

		/// <summary>
		/// Gets or sets a value indicating the location and area of the main subject in
		/// the overall scene. Variable length between 2 and 4.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort[] SubjectArea
		{
			get
			{
				return GetTagArray<ushort>("SubjectArea");
			}
			set
			{
				FreeImage.Resize(ref value, 2, 4);
				SetTagValue("SubjectArea", value);
			}
		}

		/// <summary>
		/// Gets or sets the actual focal length of the lens, in mm.
		/// Conversion is not made to the focal length of a 35 mm film camera.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? FocalLength
		{
			get
			{
				return GetTagValue<FIURational>("FocalLength");
			}
			set
			{
				SetTagValue("FocalLength", value);
			}
		}

		/// <summary>
		/// Gets or sets the strobe energy at the time the image is captured,
		/// as measured in Beam Candle Power Seconds (BCPS).
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? FlashEnergy
		{
			get
			{
				return GetTagValue<FIURational>("FlashEnergy");
			}
			set
			{
				SetTagValue("FlashEnergy", value);
			}
		}

		/// <summary>
		/// Gets or sets the camera or input device spatial frequency table and SFR values
		/// in the direction of image width, image height, and diagonal direction,
		/// as specified in ISO 12233.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte[] SpatialFrequencyResponse
		{
			get
			{
				return GetTagArray<byte>("SpatialFrequencyResponse");
			}
			set
			{
				SetTagValueUndefined("SpatialFrequencyResponse", value);
			}
		}

		/// <summary>
		/// Gets or sets the number of pixels in the image width (X) direction per
		/// FocalPlaneResolutionUnit on the camera focal plane.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? FocalPlaneXResolution
		{
			get
			{
				return GetTagValue<FIURational>("FocalPlaneXResolution");
			}
			set
			{
				SetTagValue("FocalPlaneXResolution", value);
			}
		}

		/// <summary>
		/// Gets or sets the number of pixels in the image height (Y) direction per
		/// FocalPlaneResolutionUnit on the camera focal plane.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? FocalPlaneYResolution
		{
			get
			{
				return GetTagValue<FIURational>("FocalPlaneYResolution");
			}
			set
			{
				SetTagValue("FocalPlaneYResolution", value);
			}
		}

		/// <summary>
		/// Gets or sets the unit for measuring FocalPlaneXResolution and FocalPlaneYResolution.
		/// This value is the same as the ResolutionUnit.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? FocalPlaneResolutionUnit
		{
			get
			{
				return GetTagValue<ushort>("FocalPlaneResolutionUnit");
			}
			set
			{
				SetTagValue("FocalPlaneResolutionUnit", value);
			}
		}

		/// <summary>
		/// Gets or sets the location of the main subject in the scene.
		/// The value of this tag represents the pixel at the center of the main subject
		/// relative to the left edge, prior to rotation processing as per the Rotation tag.
		/// The first value indicates the X column number and second indicates the Y row number.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? SubjectLocation
		{
			get
			{
				return GetTagValue<ushort>("SubjectLocation");
			}
			set
			{
				SetTagValue("SubjectLocation", value);
			}
		}

		/// <summary>
		/// Gets or sets the exposure index selected on the camera or input device at the
		/// time the image was captured.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? ExposureIndex
		{
			get
			{
				return GetTagValue<FIURational>("ExposureIndex");
			}
			set
			{
				SetTagValue("ExposureIndex", value);
			}
		}

		/// <summary>
		/// Gets or sets the image sensor type on the camera or input device.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are defined:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>1</term>
		///			<description>not defined</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>one-chip color area sensor</description>
		///		</item>
		///		<item>
		///			<term>3</term>
		///			<description>two-chip color area sensor</description>
		///		</item>
		///		<item>
		///			<term>4</term>
		///			<description>three-chip color area sensor</description>
		///		</item>
		///		<item>
		///			<term>5</term>
		///			<description>color sequential area sensor</description>
		///		</item>
		///		<item>
		///			<term>7</term>
		///			<description>trilinear sensor</description>
		///		</item>
		///		<item>
		///			<term>8</term>
		///			<description>color sequential linear sensor</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? SensingMethod
		{
			get
			{
				return GetTagValue<ushort>("SensingMethod");
			}
			set
			{
				SetTagValue("SensingMethod", value);
			}
		}

		/// <summary>
		/// Gets or sets the image source. If a DSC recorded the image, this tag value of this
		/// tag always be set to 3, indicating that the image was recorded on a DSC.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte? FileSource
		{
			get
			{
				return GetTagValue<byte>("FileSource");
			}
			set
			{
				SetTagValueUndefined("FileSource", value.HasValue ? new byte[] { value.Value } : null);
			}
		}

		/// <summary>
		/// Gets or sets the type of scene. If a DSC recorded the image, this tag value shall
		/// always be set to 1, indicating that the image was directly photographed.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte? SceneType
		{
			get
			{
				return GetTagValue<byte>("SceneType");
			}
			set
			{
				SetTagValueUndefined("SceneType", value.HasValue ? new byte[] { value.Value } : null);
			}
		}

		/// <summary>
		/// Gets or sets the color filter array (CFA) geometric pattern of the image sensor
		/// when a one-chip color area sensor is used. It does not apply to all sensing methods.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte[] CFAPattern
		{
			get
			{
				return GetTagArray<byte>("CFAPattern");
			}
			set
			{
				SetTagValueUndefined("CFAPattern", value);
			}
		}

		/// <summary>
		/// Gets or sets the use of special processing on image data, such as rendering geared to output.
		/// When special processing is performed, the reader is expected to disable or minimize any
		/// further processing. See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>normal process</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>custom process</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? CustomRendered
		{
			get
			{
				return GetTagValue<ushort>("CustomRendered");
			}
			set
			{
				SetTagValue("CustomRendered", value);
			}
		}

		/// <summary>
		/// Gets or sets the exposure mode set when the image was shot.
		/// In auto-bracketing mode, the camera shoots a series of frames of the same scene
		/// at different exposure settings. See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>auto exposure</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>manual exposure</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>auto bracket</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? ExposureMode
		{
			get
			{
				return GetTagValue<ushort>("ExposureMode");
			}
			set
			{
				SetTagValue("ExposureMode", value);
			}
		}

		/// <summary>
		/// Gets or sets the white balance mode set when the image was shot.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>auto white balance</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>manual white balance</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? WhiteBalance
		{
			get
			{
				return GetTagValue<ushort>("WhiteBalance");
			}
			set
			{
				SetTagValue("WhiteBalance", value);
			}
		}

		/// <summary>
		/// Gets or sets the digital zoom ratio when the image was shot.
		/// If the numerator of the recorded value is 0, this indicates that digital zoom was not used.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? DigitalZoomRatio
		{
			get
			{
				return GetTagValue<FIURational>("DigitalZoomRatio");
			}
			set
			{
				SetTagValue("DigitalZoomRatio", value);
			}
		}

		/// <summary>
		/// Gets or sets the equivalent focal length assuming a 35mm film camera, in mm.
		/// A value of 0 means the focal length is unknown. Note that this tag differs
		/// from the FocalLength tag.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? FocalLengthIn35mmFilm
		{
			get
			{
				return GetTagValue<ushort>("DigitalZoomRatio");
			}
			set
			{
				SetTagValue("DigitalZoomRatio", value);
			}
		}

		/// <summary>
		/// Gets or sets the type of scene that was shot.
		/// It can also be used to record the mode in which the image was shot.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>standard</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>landscape</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>portrait</description>
		///		</item>
		///		<item>
		///			<term>3</term>
		///			<description>night scene</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? SceneCaptureType
		{
			get
			{
				return GetTagValue<ushort>("SceneCaptureType");
			}
			set
			{
				SetTagValue("SceneCaptureType", value);
			}
		}

		/// <summary>
		/// Gets or sets the degree of overall image gain adjustment.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>none</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>low gain up</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>high gain up</description>
		///		</item>
		///		<item>
		///			<term>3</term>
		///			<description>low gain down</description>
		///		</item>
		///		<item>
		///			<term>4</term>
		///			<description>high gain down</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? GainControl
		{
			get
			{
				return GetTagValue<ushort>("GainControl");
			}
			set
			{
				SetTagValue("GainControl", value);
			}
		}

		/// <summary>
		/// Gets or sets the direction of contrast processing applied by the camera
		/// when the image was shot.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>normal</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>soft</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>hard</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? Contrast
		{
			get
			{
				return GetTagValue<ushort>("Contrast");
			}
			set
			{
				SetTagValue("Contrast", value);
			}
		}

		/// <summary>
		/// Gets or sets the direction of saturation processing applied by the camera
		/// when the image was shot.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>normal</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>low saturation</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>high saturation</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? Saturation
		{
			get
			{
				return GetTagValue<ushort>("Saturation");
			}
			set
			{
				SetTagValue("Saturation", value);
			}
		}

		/// <summary>
		/// Gets or sets the direction of sharpness processing applied by the camera
		/// when the image was shot.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>normal</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>soft</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>hard</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? Sharpness
		{
			get
			{
				return GetTagValue<ushort>("Sharpness");
			}
			set
			{
				SetTagValue("Sharpness", value);
			}
		}

		/// <summary>
		/// Gets or sets information on the picture-taking conditions of a particular camera model.
		/// The tag is used only to indicate the picture-taking conditions in the reader.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte[] DeviceSettingDescription
		{
			get
			{
				return GetTagArray<byte>("DeviceSettingDescription");
			}
			set
			{
				SetTagValueUndefined("DeviceSettingDescription", value);
			}
		}

		/// <summary>
		/// Gets or sets the distance to the subject.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>0</term>
		///			<description>unknown</description>
		///		</item>
		///		<item>
		///			<term>1</term>
		///			<description>macro</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>close view</description>
		///		</item>
		///		<item>
		///			<term>3</term>
		///			<description>distant view</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? SubjectDistanceRange
		{
			get
			{
				return GetTagValue<ushort>("SubjectDistanceRange");
			}
			set
			{
				SetTagValue("SubjectDistanceRange", value);
			}
		}

		/// <summary>
		/// Gets or sets an identifier assigned uniquely to each image.
		/// It is recorded as an ASCII string equivalent to hexadecimal notation and 128-bit fixed length.
		/// Constant length of 32.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ImageUniqueID
		{
			get
			{
				string text = GetTagText("ImageUniqueID");
				if (!string.IsNullOrEmpty(text))
				{
					text = text.Substring(0, text.Length - 1);
				}
				return text;
			}
			set
			{
				if (value != null)
				{
					FreeImage.Resize(ref value, 32);
					value += '\0';
				}
				SetTagValue("ImageUniqueID", value);
			}
		}
	}

	/// <summary>
	/// Represents a collection of all tags contained in the metadata model
	/// <see cref="FREE_IMAGE_MDMODEL.FIMD_EXIF_GPS"/>.
	/// </summary>
	public class MDM_EXIF_GPS : MetadataModel
	{
		/// <summary>
		/// Initializes a new instance of this class.
		/// </summary>
		/// <param name="dib">Handle to a FreeImage bitmap.</param>
		public MDM_EXIF_GPS(FIBITMAP dib) : base(dib) { }

		/// <summary>
		/// Retrieves the datamodel that this instance represents.
		/// </summary>
		public override FREE_IMAGE_MDMODEL Model
		{
			get { return FREE_IMAGE_MDMODEL.FIMD_EXIF_GPS; }
		}

		/// <summary>
		/// Gets or sets the GPS version ID. Constant length of 4.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte[] VersionID
		{
			get
			{
				return GetTagArray<byte>("GPSVersionID");
			}
			set
			{
				FreeImage.Resize(ref value, 4);
				SetTagValue("GPSVersionID", value);
			}
		}

		/// <summary>
		/// Gets or sets a value indicating whether the <see cref="Latitude"/>
		/// is north or south latitude.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public LatitudeType? LatitudeDirection
		{
			get
			{
				return ToLatitudeType(GetTagText("GPSLatitudeRef"));
			}
			set
			{
				SetTagValue("GPSLatitudeRef", ToString(value) + '\0');
			}
		}

		/// <summary>
		/// Gets or sets the latitude of the image. The latitude is expressed as three rational
		/// values giving the degrees, minutes, and seconds, respectively. Constant length of 3.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="LatitudeDirection"/>
		public FIURational[] Latitude
		{
			get
			{
				return GetTagArray<FIURational>("GPSLatitude");
			}
			set
			{
				FreeImage.Resize(ref value, 3);
				SetTagValue("GPSLatitude", value);
			}
		}

		/// <summary>
		/// Gets or sets a value indicating whether <see cref="Longitude"/>
		/// is east or west longitude.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public LongitudeType? LongitudeDirection
		{
			get
			{
				return ToLongitudeType(GetTagText("GPSLongitudeRef"));
			}
			set
			{
				SetTagValue("GPSLongitudeRef", ToString(value) + '\0');
			}
		}

		/// <summary>
		/// Gets or sets the longitude of the image. The longitude is expressed as three rational
		/// values giving the degrees, minutes, and seconds, respectively. Constant length of 3.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="LongitudeDirection"/>
		public FIURational[] Longitude
		{
			get
			{
				return GetTagArray<FIURational>("GPSLongitude");
			}
			set
			{
				FreeImage.Resize(ref value, 3);
				SetTagValue("GPSLongitude", value);
			}
		}

		/// <summary>
		/// Gets a value indicating whether <see cref="Altitude"/> is sea level and the altitude
		/// is above sea level. If the altitude is below sea level <see cref="Altitude"/> is
		/// indicated as an absolute value.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public AltitudeType? AltitudeDirection
		{
			get
			{
				byte? flag = GetTagValue<byte>("GPSAltitudeRef");
				if (flag.HasValue)
				{
					return flag.Value switch
					{
						0 => AltitudeType.AboveSeaLevel,
						1 => AltitudeType.BelowSeaLevel,
						_ => AltitudeType.Undefined
					};
				}
				return null;
			}
			set
			{
				byte? val = null;
				if (value.HasValue)
				{
					val = value.Value switch
					{
						AltitudeType.AboveSeaLevel => 0,
						AltitudeType.BelowSeaLevel => 1,
						_ => 2
					};
				}
				SetTagValue("GPSAltitudeRef", val);
			}
		}

		/// <summary>
		/// Gets or sets the altitude based on the reference in <see cref="AltitudeDirection"/>.
		/// Altitude is expressed as one rational value. The reference unit is meters.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? Altitude
		{
			get
			{
				return GetTagValue<FIURational>("GPSAltitude");
			}
			set
			{
				SetTagValue("GPSAltitude", value);
			}
		}

		/// <summary>
		/// Gets or sets the sign of the <see cref="SignedAltitude"/>.
		/// </summary>
		/// <remarks>
		/// This is a derived property. There is no metadata tag directly associated
		/// with this property value.
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public int? AltitudeSign
		{
			get
			{
				AltitudeType? seaLevel = AltitudeDirection;
				if (seaLevel.HasValue)
				{
					return (seaLevel.Value == AltitudeType.BelowSeaLevel) ? -1 : 1;
				}
				return null;
			}
			set
			{
				if (value.HasValue)
				{
					AltitudeDirection = value.Value >= 0 ? AltitudeType.AboveSeaLevel : AltitudeType.BelowSeaLevel;
				}
				else
				{
					AltitudeDirection = null;
				}
			}
		}

		/// <summary>
		/// Gets or sets the signed altitude.
		/// Altitude is expressed as one rational value. The reference unit is meters.
		/// </summary>
		/// <exception cref="OverflowException">
		/// Altitude is too large to fit into a FIRational.
		/// </exception>
		/// <remarks>
		/// This is a derived property. There is no metadata tag directly associated
		/// with this property value.
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIRational? SignedAltitude
		{
			get
			{
				FIRational? result = null;
				FIURational? altitude = Altitude;
				if (altitude.HasValue)
				{
					int sign = AltitudeSign ?? 1;
					if (((int)altitude.Value.Numerator < 0) || ((int)altitude.Value.Denominator < 0))
						throw new OverflowException();
					result = new FIRational((int)altitude.Value.Numerator * sign, (int)altitude.Value.Denominator);
				}
				return result;
			}
			set
			{
				FIURational? val = null;
				if (value.HasValue)
				{
					if (value.Value < 0)
					{
						AltitudeSign = -1;
						value = -value.Value;
					}
					else
					{
						AltitudeSign = 1;
					}
					val = new FIURational((uint)value.Value.Numerator, (uint)value.Value.Denominator);
				}
				Altitude = val;
			}
		}


		/// <summary>
		/// Gets or sets the time as UTC (Coordinated Universal Time). Constant length of 3.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public TimeSpan? TimeStamp
		{
			get
			{
				FIURational[] stamp = GetTagArray<FIURational>("GPSTimeStamp");
				if ((stamp == null) || stamp.Length != 3)
				{
					return null;
				}

				return new TimeSpan((int)stamp[0], (int)stamp[1], (int)stamp[2]);
			}
			set
			{
				FIURational[] stamp = null;
				if (value.HasValue)
				{
					TimeSpan span = value.Value;
					stamp = new FIURational[3];
					stamp[0] = span.Hours;
					stamp[1] = span.Minutes;
					stamp[2] = span.Seconds;
				}
				SetTagValue("GPSTimeStamp", stamp);
			}
		}

		/// <summary>
		/// Gets or sets the GPS satellites used for measurements. This tag can be used to describe
		/// the number of satellites, their ID number, angle of elevation, azimuth, SNR and other
		/// information in ASCII notation. The format is not specified.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Satellites
		{
			get
			{
				string result = GetTagText("GPSSatellites");
				if (!string.IsNullOrEmpty(result))
				{
					result = result.Substring(0, result.Length - 1);
				}
				return result;
			}
			set
			{
				if (value != null)
				{
					value += '\0';
				}
				SetTagValue("GPSTimeStamp", value);
			}
		}

		/// <summary>
		/// Gets or sets a value indicating the status of the GPS receiver when the image was recorded.
		/// <b>true</b> indicates measurement was in progress;
		/// <b>false</b> indicates measurement was Interoperability.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public bool? Status
		{
			get
			{
				string text = GetTagText("GPSStatus");
				return string.IsNullOrEmpty(text) ? default(bool?) : text[0] == 'A';
			}
			set
			{
				SetTagValue("GPSStatus", value.HasValue ? (value.Value ? "A\0" : "V\0") : null);
			}
		}

		/// <summary>
		/// Gets or sets a value indicating the GPS measurement mode.
		/// <b>true</b> indicates three-dimensional measurement;
		/// <b>false</b> indicated two-dimensional measurement was in progress.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public bool? MeasureMode3D
		{
			get
			{
				string text = GetTagText("GPSMeasureMode");
				return string.IsNullOrEmpty(text) ? default(bool?) : text[0] == '3';
			}
			set
			{
				SetTagValue("GPSMeasureMode", value.HasValue ? (value.Value ? "3\0" : "2\0") : null);
			}
		}

		/// <summary>
		/// Gets or sets the GPS DOP (data degree of precision). An HDOP value is written during
		/// two-dimensional measurement, and PDOP during three-dimensional measurement.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? DOP
		{
			get
			{
				return GetTagValue<FIURational>("GPSDOP");
			}
			set
			{
				SetTagValue("GPSDOP", value);
			}
		}

		/// <summary>
		/// Gets or sets the unit used to express the GPS receiver <see cref="Speed"/> of movement.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="Speed"/>
		public VelocityUnit? SpeedUnit
		{
			get
			{
				return ToUnitType(GetTagText("GPSSpeedRef"));
			}
			set
			{
				SetTagValue("GPSSpeedRef", ToString(value) + '\0');
			}
		}

		/// <summary>
		/// Gets or sets the speed of GPS receiver movement.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="SpeedUnit"/>
		public FIURational? Speed
		{
			get
			{
				return GetTagValue<FIURational>("GPSSpeed");
			}
			set
			{
				SetTagValue("GPSSpeed", value);
			}
		}

		/// <summary>
		/// Gets or sets the reference for giving the direction of GPS receiver movement.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="Track"/>
		public DirectionReference? TrackDirectionReference
		{
			get
			{
				return ToDirectionType(GetTagText("GPSTrackRef"));
			}
			set
			{
				SetTagValue("GPSTrackRef", ToString(value) + '\0');
			}
		}

		/// <summary>
		/// Gets or sets the direction of GPS receiver movement.
		/// The range of values is from 0.00 to 359.99.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="TrackDirectionReference"/>
		public FIURational? Track
		{
			get
			{
				return GetTagValue<FIURational>("GPSTrack");
			}
			set
			{
				SetTagValue("GPSTrack", value);
			}
		}

		/// <summary>
		/// Gets or sets the reference for giving the direction of GPS receiver movement.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="ImageDirection"/>
		public DirectionReference? ImageDirectionReference
		{
			get
			{
				return ToDirectionType(GetTagText("GPSImgDirectionRef"));
			}
			set
			{
				SetTagValue("GPSImgDirectionRef", ToString(value) + '\0');
			}
		}

		/// <summary>
		/// Gets or sets the direction of the image when it was captured.
		/// The range of values is from 0.00 to 359.99.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="ImageDirectionReference"/>
		public FIURational? ImageDirection
		{
			get
			{
				return GetTagValue<FIURational>("GPSImgDirection");
			}
			set
			{
				SetTagValue("GPSImgDirection", value);
			}
		}

		/// <summary>
		/// Gets or sets the geodetic survey data used by the GPS receiver. If the survey data
		/// is restricted to Japan, the value of this tag is 'TOKYO' or 'WGS-84'.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string MapDatum
		{
			get
			{
				string result = GetTagText("GPSMapDatum");
				if (!string.IsNullOrEmpty(result))
				{
					result = result.Substring(0, result.Length - 1);
				}
				return result;
			}
			set
			{
				SetTagValue("GPSMapDatum", value + '\0');
			}
		}

		/// <summary>
		/// Gets or sets a value indicating whether the destination point
		/// is north or south latitude.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="Latitude"/>
		public LatitudeType? DestinationLatitudeDirection
		{
			get
			{
				return ToLatitudeType(GetTagText("GPSDestLatitudeRef"));
			}
			set
			{
				SetTagValue("GPSDestLatitudeRef", ToString(value) + '\0');
			}
		}

		/// <summary>
		/// Gets or sets the latitude of the destination point. The latitude is expressed as three rational
		/// values giving the degrees, minutes, and seconds, respectively. Constant length of 3.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="DestinationLatitudeDirection"/>
		public FIURational[] DestinationLatitude
		{
			get
			{
				return GetTagArray<FIURational>("GPSDestLatitude");
			}
			set
			{
				FreeImage.Resize(ref value, 3);
				SetTagValue("GPSDestLatitude", value);
			}
		}

		/// <summary>
		/// Gets or sets a value indicating whether the destination point
		/// is east or west longitude.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="Latitude"/>
		public LongitudeType? DestinationLongitudeDirection
		{
			get
			{
				return ToLongitudeType(GetTagText("GPSDestLongitudeRef"));
			}
			set
			{
				SetTagValue("GPSDestLongitudeRef", ToString(value) + '\0');
			}
		}

		/// <summary>
		/// Gets or sets the longitude of the destination point. The longitude is expressed as three rational
		/// values giving the degrees, minutes, and seconds, respectively. Constant length of 3.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational[] DestinationLongitude
		{
			get
			{
				return GetTagArray<FIURational>("GPSDestLongitude");
			}
			set
			{
				FreeImage.Resize(ref value, 3);
				SetTagValue("GPSDestLongitude", value);
			}
		}

		/// <summary>
		/// Gets or sets the reference used for giving the bearing to the destination point.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="DestinationBearing"/>
		public DirectionReference? DestinationDirectionReference
		{
			get
			{
				return ToDirectionType(GetTagText("GPSDestBearingRef"));
			}
			set
			{
				SetTagValue("GPSDestBearingRef", ToString(value) + '\0');
			}
		}

		/// <summary>
		/// Gets or sets the bearing to the destination point.
		/// The range of values is from 0.00 to 359.99.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="DestinationDirectionReference"/>
		public FIURational? DestinationBearing
		{
			get
			{
				return GetTagValue<FIURational>("GPSDestBearing");
			}
			set
			{
				SetTagValue("GPSDestBearing", value);
			}
		}

		/// <summary>
		/// Gets or sets the unit used to express the distance to the destination point.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="DestinationBearing"/>
		public VelocityUnit? DestinationUnit
		{
			get
			{
				return ToUnitType(GetTagText("GPSDestDistanceRef"));
			}
			set
			{
				SetTagValue("GPSDestDistanceRef", ToString(value) + '\0');
			}
		}

		/// <summary>
		/// Gets or sets a character string recording the name of the method used
		/// for location finding. The first byte indicates the character code used,
		/// and this is followed by the name of the method. Since the Type is not ASCII,
		/// NULL termination is not necessary.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte[] ProcessingMethod
		{
			get
			{
				return GetTagArray<byte>("GPSProcessingMethod");
			}
			set
			{
				SetTagValue("GPSProcessingMethod", value);
			}
		}

		/// <summary>
		/// Gets or sets a character string recording the name of the GPS area.
		/// The first byte indicates the character code used, and this is followed by
		/// the name of the GPS area. Since the Type is not ASCII, NULL termination is
		/// not necessary. 
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public byte[] AreaInformation
		{
			get
			{
				return GetTagArray<byte>("GPSAreaInformation");
			}
			set
			{
				SetTagValue("GPSAreaInformation", value);
			}
		}

		/// <summary>
		/// Gets or sets date and time information relative to UTC (Coordinated Universal Time). 
		/// </summary>
		/// <remarks>
		/// This is a derived property. There is no metadata tag directly associated
		/// with this property value.
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public DateTime? DateTimeStamp
		{
			get
			{
				DateTime? date = DateStamp;
				TimeSpan? time = TimeStamp;
				if ((date == null) && (time == null))
				{
					return null;
				}

				date ??= DateTime.MinValue;
				time ??= TimeSpan.MinValue;
				return date.Value.Add(time.Value);
			}
			set
			{
				if (value.HasValue)
				{
					DateStamp = value.Value.Date;
					TimeStamp = value.Value.TimeOfDay;
				}
				else
				{
					DateStamp = null;
					TimeStamp = null;
				}
			}
		}

		/// <summary>
		/// Gets or sets date information relative to UTC (Coordinated Universal Time).
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public DateTime? DateStamp
		{
			get
			{
				string stamp = GetTagText("GPSDateStamp");
				if (stamp != null)
				{
					try
					{
						return DateTime.ParseExact(stamp, "yyyy:MM:dd\0", null);
					}
					catch
					{
					}
				}
				return null;
			}
			set
			{
				string val = null;
				if (value.HasValue)
				{
					try
					{
						val = value.Value.ToString("yyyy:MM:dd\0");
					}
					catch
					{
					}
				}
				SetTagValue("GPSDateStamp", val);
			}
		}

		/// <summary>
		/// Gets or sets a value indicating whether differential correction was applied to
		/// the GPS receiver. 
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public bool? IsDifferential
		{
			get
			{
				ushort? value = GetTagValue<ushort>("GPSDifferential");
				return value.HasValue ? (value != 0) : (default(bool?));
			}
			set
			{
				SetTagValue("GPSDifferential", value.HasValue ? (object)(value.Value ? (ushort)1 : (ushort)0) : (null));
			}
		}
	}

	/// <summary>
	/// Represents a collection of all tags contained in the metadata model
	/// <see cref="FREE_IMAGE_MDMODEL.FIMD_EXIF_INTEROP"/>.
	/// </summary>
	public class MDM_INTEROP : MetadataModel
	{
		/// <summary>
		/// Initializes a new instance of this class.
		/// </summary>
		/// <param name="dib">Handle to a FreeImage bitmap.</param>
		public MDM_INTEROP(FIBITMAP dib) : base(dib) { }

		/// <summary>
		/// Retrieves the datamodel that this instance represents.
		/// </summary>
		public override FREE_IMAGE_MDMODEL Model
		{
			get { return FREE_IMAGE_MDMODEL.FIMD_EXIF_INTEROP; }
		}

		/// <summary>
		/// Gets or sets the identification of the Interoperability rule.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public InteroperabilityMode? Identification
		{
			get
			{
				return ToInteroperabilityType(GetTagText("InteroperabilityIndex"));
			}
			set
			{
				SetTagValue("InteroperabilityIndex", ToString(value) + '\0');
			}
		}
	}

	/// <summary>
	/// Represents a collection of all tags contained in the metadata model
	/// <see cref="FREE_IMAGE_MDMODEL.FIMD_EXIF_MAIN"/>.
	/// </summary>
	public class MDM_EXIF_MAIN : MetadataModel
	{
		/// <summary>
		/// Initializes a new instance of this class.
		/// </summary>
		/// <param name="dib">Handle to a FreeImage bitmap.</param>
		public MDM_EXIF_MAIN(FIBITMAP dib) : base(dib) { }

		/// <summary>
		/// Retrieves the datamodel that this instance represents.
		/// </summary>
		public override FREE_IMAGE_MDMODEL Model
		{
			get { return FREE_IMAGE_MDMODEL.FIMD_EXIF_MAIN; }
		}

		/// <summary>
		/// Gets or sets the number of columns of image data, equal to the number
		/// of pixels per row. In JPEG compressed data a JPEG marker is used
		/// instead of this tag.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public uint? ImageWidth
		{
			get
			{
				return GetUInt32Value("ImageWidth");
			}
			set
			{
				RemoveTag("ImageWidth");
				if (value.HasValue)
				{
					SetTagValue("ImageWidth", value);
				}
			}
		}

		/// <summary>
		/// Gets or sets number of rows of image data. In JPEG compressed data a JPEG marker
		/// is used instead of this tag.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public uint? ImageHeight
		{
			get
			{
				return GetUInt32Value("ImageLength");
			}
			set
			{
				RemoveTag("ImageLength");
				if (value.HasValue)
				{
					SetTagValue("ImageLength", value);
				}
			}
		}

		/// <summary>
		/// Gets or sets number of bits per image component. In this standard
		/// each component of the image is 8 bits, so the value for this tag is 8.
		/// Constant length of 3.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort[] BitsPerSample
		{
			get
			{
				return GetTagArray<ushort>("BitsPerSample");
			}
			set
			{
				FreeImage.Resize(ref value, 3);
				SetTagValue("BitsPerSample", value);
			}
		}

		/// <summary>
		/// Gets or sets compression scheme used for the image data. When a primary image
		/// is JPEG compressed, this designation is not necessary and is omitted.
		/// When thumbnails use JPEG compression, this tag value is set to 6.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? Compression
		{
			get
			{
				return GetTagValue<ushort>("Compression");
			}
			set
			{
				SetTagValue("Compression", value);
			}
		}

		/// <summary>
		/// Gets or sets pixel composition. In JPEG compressed data a JPEG marker is
		/// used instead of this tag. See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>2</term>
		///			<description>RGB</description>
		///		</item>
		///		<item>
		///			<term>6</term>
		///			<description>YCbCr</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? PhotometricInterpretation
		{
			get
			{
				return GetTagValue<ushort>("PhotometricInterpretation");
			}
			set
			{
				SetTagValue("PhotometricInterpretation", value);
			}
		}

		/// <summary>
		/// Gets or sets the image orientation viewed in terms of rows and columns.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ExifImageOrientation? Orientation
		{
			get
			{
				return (ExifImageOrientation?)GetTagValue<ushort>("Orientation");
			}
			set
			{
				SetTagValue("Orientation", (ushort?)value);
			}
		}

		/// <summary>
		/// Gets or sets the number of components per pixel. Since this standard applies
		/// to RGB and YCbCr images, the value set for this tag is 3. In JPEG compressed
		/// data a JPEG marker is used instead of this tag.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? SamplesPerPixel
		{
			get
			{
				return GetTagValue<ushort>("SamplesPerPixel");
			}
			set
			{
				SetTagValue("SamplesPerPixel", value);
			}
		}

		/// <summary>
		/// Gets or sets a value that indicates whether pixel components are recorded in
		/// chunky or planar format. In JPEG compressed files a JPEG marker is used instead
		/// of this tag. If this field does not exist, the TIFF default of 1 (chunky) is assumed.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>1</term>
		///			<description>chunky format</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>planar format</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? PlanarConfiguration
		{
			get
			{
				return GetTagValue<ushort>("PlanarConfiguration");
			}
			set
			{
				SetTagValue("PlanarConfiguration", value);
			}
		}

		/// <summary>
		/// Gets or sets the sampling ratio of chrominance components in relation to
		/// the luminance component. In JPEG compressed dat a JPEG marker is used
		/// instead of this tag.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>[2,1]</term>
		///			<description>YCbCr4:2:2</description>
		///		</item>
		///		<item>
		///			<term>[2,2]</term>
		///			<description>YCbCr4:2:0</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort[] YCbCrSubSampling
		{
			get
			{
				return GetTagArray<ushort>("YCbCrSubSampling");
			}
			set
			{
				FreeImage.Resize(ref value, 2);
				SetTagValue("YCbCrSubSampling", value);
			}
		}

		/// <summary>
		/// Gets or sets position of chrominance components in relation to the luminance component.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// This field is designated only for JPEG compressed data or uncompressed YCbCr data.
		/// The TIFF default is 1 (centered); but when Y:Cb:Cr = 4:2:2 it is recommended in
		/// this standard that 2 (co-sited) be used to record data, in order to improve the
		/// image quality when viewed on TV systems.
		/// <para/>
		/// When this field does not exist, the reader shall assume the TIFF default.
		/// In the case of Y:Cb:Cr = 4:2:0, the TIFF default (centered) is recommended.
		/// If the reader does not have the capability of supporting both kinds of YCbCrPositioning,
		/// it shall follow the TIFF default regardless of the value in this field.
		/// It is preferable that readers be able to support both centered and co-sited positioning.
		/// <para/>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>1</term>
		///			<description>centered</description>
		///		</item>
		///		<item>
		///			<term>2</term>
		///			<description>co-sited</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>reserved</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? YCbCrPositioning
		{
			get
			{
				return GetTagValue<ushort>("YCbCrPositioning");
			}
			set
			{
				SetTagValue("YCbCrPositioning", value);
			}
		}

		/// <summary>
		/// Gets or sets the number of pixels per <see cref="ResolutionUnit"/>
		/// in the <see cref="ImageWidth"/> direction. When the image resolution is unknown,
		/// 72 [dpi] is designated.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? XResolution
		{
			get
			{
				return GetTagValue<FIURational>("XResolution");
			}
			set
			{
				SetTagValue("XResolution", value);
			}
		}

		/// <summary>
		/// Gets or sets the number of pixels per <see cref="ResolutionUnit"/>
		/// in the <see cref="ImageHeight"/> direction. When the image resolution is unknown,
		/// 72 [dpi] is designated.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational? YResolution
		{
			get
			{
				return GetTagValue<FIURational>("YResolution");
			}
			set
			{
				SetTagValue("YResolution", value);
			}
		}

		/// <summary>
		/// Gets or sets the unit for measuring <see cref="XResolution"/> and <see cref="YResolution"/>.
		/// The same unit is used for both <see cref="XResolution"/> and <see cref="YResolution"/>.
		/// If the image resolution in unknown, 2 (inches) is designated.
		/// See remarks for further information.
		/// </summary>
		/// <remarks>
		/// The following values are definied:<para/>
		/// <list type="table">
		///		<listheader>
		///			<term>ID</term>
		///			<description>Description</description>
		///		</listheader>
		///		<item>
		///			<term>2</term>
		///			<description>inches</description>
		///		</item>
		///		<item>
		///			<term>3</term>
		///			<description>YCbCr4:2:0</description>
		///		</item>
		///		<item>
		///			<term>other</term>
		///			<description>centimeters</description>
		///		</item>
		/// </list>
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort? ResolutionUnit
		{
			get
			{
				return GetTagValue<ushort>("ResolutionUnit");
			}
			set
			{
				SetTagValue("ResolutionUnit", value);
			}
		}

		/// <summary>
		/// Gets or sets the byte offset of that strip.
		/// It is recommended that this be selected so the number of strip bytes
		/// does not exceed 64 Kbytes.
		/// With JPEG compressed data this designation is not needed and is omitted.
		/// Constant length of <see cref="SamplesPerPixel"/> * StripsPerImage.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="RowsPerStrip"/>
		/// <see cref="StripByteCounts"/>
		public uint[] StripOffsets
		{
			get
			{
				return GetUInt32Array("StripOffsets");
			}
			set
			{
				RemoveTag("StripOffsets");
				if (value != null)
				{
					SetTagValue("StripOffsets", value);
				}
			}
		}

		/// <summary>
		/// Gets or sets number of rows per strip. This is the number of rows in the image of
		/// one strip when an image is divided into strips. With JPEG compressed data this
		/// designation is not needed and is omitted.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		/// <seealso cref="StripByteCounts"/>
		public uint? RowsPerStrip
		{
			get
			{
				return GetUInt32Value("RowsPerStrip");
			}
			set
			{
				RemoveTag("RowsPerStrip");
				if (value.HasValue)
				{
					SetTagValue("RowsPerStrip", value);
				}
			}
		}

		/// <summary>
		/// Gets or sets the total number of bytes in each strip.
		/// With JPEG compressed data this designation is not needed and is omitted.
		/// Constant length of <see cref="SamplesPerPixel"/> * StripsPerImage.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public uint[] StripByteCounts
		{
			get
			{
				return GetUInt32Array("StripByteCounts");
			}
			set
			{
				RemoveTag("StripByteCounts");
				if (value != null)
				{
					SetTagValue("StripByteCounts", value);
				}
			}
		}

		/// <summary>
		/// Gets or sets the offset to the start byte (SOI) of JPEG compressed thumbnail data.
		/// This is not used for primary image JPEG data.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public uint? JPEGInterchangeFormat
		{
			get
			{
				return GetTagValue<uint>("JPEGInterchangeFormat");
			}
			set
			{
				SetTagValue("JPEGInterchangeFormat", value);
			}
		}

		/// <summary>
		/// Gets or sets the number of bytes of JPEG compressed thumbnail data.
		/// </summary>
		/// <remarks>
		/// This is not used for primary image JPEG data.
		/// JPEG thumbnails are not divided but are recorded as a continuous
		/// JPEG bitstream from SOI to EOI. APPn and COM markers should not be recorded.
		/// Compressed thumbnails shall be recorded in no more than 64 Kbytes,
		/// including all other data to be recorded in APP1.
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public uint? JPEGInterchangeFormatLength
		{
			get
			{
				return GetTagValue<uint>("JPEGInterchangeFormatLength");
			}
			set
			{
				SetTagValue("JPEGInterchangeFormatLength", value);
			}
		}

		/// <summary>
		/// Gets or sets a transfer function for the image, described in tabular style.
		/// Constant length of 3 * 256.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort[] TransferFunction
		{
			get
			{
				return GetTagArray<ushort>("TransferFunction");
			}
			set
			{
				FreeImage.Resize(ref value, 3 * 256);
				SetTagValue("TransferFunction", value);
			}
		}

		/// <summary>
		/// Gets or sets the chromaticity of the white point of the image.
		/// Constant length of 2.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational[] WhitePoint
		{
			get
			{
				return GetTagArray<FIURational>("WhitePoint");
			}
			set
			{
				FreeImage.Resize(ref value, 2);
				SetTagValue("WhitePoint", value);
			}
		}

		/// <summary>
		/// Gets or sets the chromaticity of the three primary colors of the image.
		/// Constant length of 6.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational[] PrimaryChromaticities
		{
			get
			{
				return GetTagArray<FIURational>("PrimaryChromaticities");
			}
			set
			{
				FreeImage.Resize(ref value, 6);
				SetTagValue("PrimaryChromaticities", value);
			}
		}

		/// <summary>
		/// Gets or sets the matrix coefficients for transformation from RGB to YCbCr image data.
		/// Constant length of 3.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational[] YCbCrCoefficients
		{
			get
			{
				return GetTagArray<FIURational>("YCbCrCoefficients");
			}
			set
			{
				FreeImage.Resize(ref value, 3);
				SetTagValue("PrimaryChromaticities", value);
			}
		}

		/// <summary>
		/// Gets or sets the reference black point value and reference white point value.
		/// Constant length of 6.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public FIURational[] ReferenceBlackWhite
		{
			get
			{
				return GetTagArray<FIURational>("ReferenceBlackWhite");
			}
			set
			{
				FreeImage.Resize(ref value, 6);
				SetTagValue("ReferenceBlackWhite", value);
			}
		}

		/// <summary>
		/// Gets or sets the date and time of image creation.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public DateTime? DateTime
		{
			get
			{
				DateTime? result = null;
				string text = GetTagText("DateTime");
				if (text != null)
				{
					try
					{
						result = System.DateTime.ParseExact(text, "yyyy:MM:dd HH:mm:ss\0", null);
					}
					catch
					{
					}
				}
				return result;
			}
			set
			{
				string val = null;
				if (value.HasValue)
				{
					try
					{
						val = value.Value.ToString("yyyy:MM:dd HH:mm:ss\0");
					}
					catch
					{
					}
				}
				SetTagValue("DateTime", val);
			}
		}

		/// <summary>
		/// Gets or sets a string giving the title of the image.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ImageDescription
		{
			get
			{
				string result = GetTagText("ImageDescription");
				if (!string.IsNullOrEmpty(result))
				{
					result = result.Substring(0, result.Length - 1);
				}
				return result;
			}
			set
			{
				if (value != null)
				{
					value += '\0';
				}
				SetTagValue("ImageDescription", value);
			}
		}

		/// <summary>
		/// Gets or sets the manufacturer of the recording equipment.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Make
		{
			get
			{
				string result = GetTagText("Make");
				if (!string.IsNullOrEmpty(result))
				{
					result = result.Substring(0, result.Length - 1);
				}
				return result;
			}
			set
			{
				if (value != null)
				{
					value += '\0';
				}
				SetTagValue("Make", value);
			}
		}

		/// <summary>
		/// Gets or sets the model name or model number of the equipment.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string EquipmentModel
		{
			get
			{
				string result = GetTagText("Model");
				if (!string.IsNullOrEmpty(result))
				{
					result = result.Substring(0, result.Length - 1);
				}
				return result;
			}
			set
			{
				if (value != null)
				{
					value += '\0';
				}
				SetTagValue("Model", value);
			}
		}

		/// <summary>
		/// Gets or sets the name and version of the software or firmware of the camera
		/// or image input device used to generate the image.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Software
		{
			get
			{
				string result = GetTagText("Software");
				if (!string.IsNullOrEmpty(result))
				{
					result = result.Substring(0, result.Length - 1);
				}
				return result;
			}
			set
			{
				if (value != null)
				{
					value += '\0';
				}
				SetTagValue("Software", value);
			}
		}

		/// <summary>
		/// Gets or sets the name of the camera owner, photographer or image creator.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Artist
		{
			get
			{
				string result = GetTagText("Artist");
				if (!string.IsNullOrEmpty(result))
				{
					result = result.Substring(0, result.Length - 1);
				}
				return result;
			}
			set
			{
				if (value != null)
				{
					value += '\0';
				}
				SetTagValue("Artist", value);
			}
		}

		/// <summary>
		/// Gets or sets the photographer and editor copyrights.
		/// Constant length of 1-2.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string[] Copyright
		{
			get
			{
				string[] result = null;
				string text = GetTagText("Copyright");
				if (!string.IsNullOrEmpty(text))
				{
					result = text.Split(['\0'], StringSplitOptions.RemoveEmptyEntries);
				}
				return result;
			}
			set
			{
				string val = null;
				if (value != null)
				{
					if (value.Length == 1)
					{
						if (value[0] != null)
						{
							val = value[0] + '\0';
						}
					}
					else if (value.Length == 2)
					{
						if ((value[0] != null) && (value[1] != null))
						{
							val = value[0] + '\0' + value[1] + '\0';
						}
					}
				}
				SetTagValue("Copyright", val);
			}
		}
	}

	/// <summary>
	/// Represents a collection of all tags contained in the metadata model
	/// <see cref="FREE_IMAGE_MDMODEL.FIMD_EXIF_MAKERNOTE"/>.
	/// </summary>
	public class MDM_MAKERNOTE : MetadataModel
	{
		/// <summary>
		/// Initializes a new instance of this class.
		/// </summary>
		/// <param name="dib">Handle to a FreeImage bitmap.</param>
		public MDM_MAKERNOTE(FIBITMAP dib) : base(dib) { }

		/// <summary>
		/// Retrieves the datamodel that this instance represents.
		/// </summary>
		public override FREE_IMAGE_MDMODEL Model
		{
			get { return FREE_IMAGE_MDMODEL.FIMD_EXIF_MAKERNOTE; }
		}
	}

	/// <summary>
	/// Represents a collection of all tags contained in the metadata model
	/// <see cref="FREE_IMAGE_MDMODEL.FIMD_GEOTIFF"/>.
	/// </summary>
	public class MDM_GEOTIFF : MetadataModel
	{
		/// <summary>
		/// Initializes a new instance of this class.
		/// </summary>
		/// <param name="dib">Handle to a FreeImage bitmap.</param>
		public MDM_GEOTIFF(FIBITMAP dib) : base(dib) { }

		/// <summary>
		/// Retrieves the datamodel that this instance represents.
		/// </summary>
		public override FREE_IMAGE_MDMODEL Model
		{
			get { return FREE_IMAGE_MDMODEL.FIMD_GEOTIFF; }
		}

		/// <summary>
		/// Gets or sets the value of the GeoTIFF GeoASCIIParamsTag.
		/// </summary>
		/// <remarks>
		/// The GeoASCIIParamsTag is used to store all of the <see cref="String"/> valued
		/// GeoKeys, referenced by the <see cref="GeoKeyDirectory"/> property. Since keys
		/// defined in the GeoKeyDirectoryTag use offsets into this tag, any special
		/// comments may be placed at the beginning of this tag.
		/// For the most part, the only keys that are <see cref="String"/> valued are
		/// <i>Citation</i> keys, giving documentation and references for obscure
		/// projections, datums, etc.
		/// <para/>
		/// Special handling is required for <see cref="String"/>-valued keys. While it
		/// is true that TIFF 6.0 permits multiple NULL-delimited strings within a single
		/// ASCII tag, the secondary strings might not appear in the output of naive
		/// <i>tiffdump</i> programs. For this reason, the NULL delimiter of each ASCII key
		/// value shall be converted to a "|" (pipe) character before being installed
		/// back into the <see cref="String"/> holding tag, so that a dump of the tag
		/// will look like this.
		/// <para/>
		/// AsciiTag="first_value|second_value|etc...last_value|"
		/// <para/>
		/// A baseline GeoTIFF-reader must check for and convert the final "|" pipe 
		/// character of a key back into a NULL before returning it to the client 
		/// software.
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string GeoASCIIParams
		{
			get
			{
				string text = GetTagText("GeoASCIIParams");
				if (!string.IsNullOrEmpty(text))
				{
					text = text.Substring(0, text.Length - 1);
				}
				return text;
			}
			set
			{
				if (value != null)
				{
					value += '\0';
				}
				SetTagValue("GeoASCIIParams", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the GeoTIFF GeoDoubleParamsTag.
		/// </summary>
		/// <remarks>
		/// The GeoDoubleParamsTag is used to store all of the <see cref="Double"/> valued
		/// GeoKeys, referenced by the <see cref="GeoKeyDirectory"/> property. The meaning of
		/// any value of this double array is determined from the GeoKeyDirectoryTag reference
		/// pointing to it. <see cref="Single"/> values should first be converted to
		/// <see cref="Double"/> and stored here.
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public double[] GeoDoubleParams
		{
			get
			{
				return GetTagArray<double>("GeoDoubleParams");
			}
			set
			{
				SetTagValue("GeoDoubleParams", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the GeoTIFF GeoKeyDirectoryTag.
		/// </summary>
		/// <remarks>
		/// The GeoKeyDirectoryTag may be used to store the GeoKey Directory, which defines and
		/// references the <i>GeoKeys</i>.
		/// <para/>
		/// The tag is an array of unsigned <see cref="UInt16"/> values, which are primarily
		/// grouped into blocks of 4. The first 4 values are special, and contain GeoKey directory
		/// header information. The header values consist of the following information, in order:
		/// <para/>
		/// Header={KeyDirectoryVersion, KeyRevision, MinorRevision, NumberOfKeys}
		/// <para/>
		/// where
		/// <para/>
		/// <i>KeyDirectoryVersion</i> indicates the current version of Key implementation, and will
		/// only change if this Tag's Key structure is changed. (Similar to the TIFFVersion (42)).
		/// The current DirectoryVersion number is 1. This value will most likely never change,
		/// and may be used to ensure that this is a valid Key-implementation.
		/// <para/>
		/// <i>KeyRevision</i> indicates what revision of Key-Sets are used.
		/// <para/>
		/// <i>MinorRevision</i> indicates what set of Key-Codes are used. The complete revision number
		/// is denoted &lt;KeyRevision&gt;.&lt;MinorRevision&gt;.
		/// <para/>
		/// <i>NumberOfKeys</i> indicates how many Keys are defined by the rest of this Tag.
		/// <para/>
		/// This header is immediately followed by a collection of &lt;NumberOfKeys&gt; KeyEntry
		/// sets, each of which is also 4-<see cref="UInt16"/> long. Each KeyEntry is modeled on the
		/// <i>TIFFEntry</i> format of the TIFF directory header, and is of the form:
		/// <para/>
		/// KeyEntry = { KeyID, TIFFTagLocation, Count, Value_Offset }
		/// <para/>
		/// where
		/// <para/>
		/// <i>KeyID</i> gives the Key-ID value of the Key (identical in function to TIFF tag ID,
		/// but completely independent of TIFF tag-space),
		/// <para/>
		/// <i>TIFFTagLocation</i> indicates which TIFF tag contains the value(s) of the Key: if
		/// TIFFTagLocation is 0, then the value is <see cref="UInt16"/>, and is contained in the
		/// <i>Value_Offset</i> entry. Otherwise, the type (format) of the value is implied by the
		/// TIFF-Type of the tag containing the value.
		/// <para/>
		/// <i>Count</i> indicates the number of values in this key.
		/// <para/>
		/// <i>Value_Offset</i> Value_Offset indicates the index-offset into the TagArray indicated
		/// by TIFFTagLocation, if it is nonzero. If TIFFTagLocation is 0 (zero) , then Value_Offset 
		/// contains the actual (<see cref="UInt16"/>) value of the Key, and Count=1 is implied.
		/// Note that the offset is not a byte-offset, but rather an index based on the natural data
		/// type of the specified tag array.
		/// <para/>
		/// Following the KeyEntry definitions, the KeyDirectory tag may also contain additional
		/// values. For example, if a key requires multiple <see cref="UInt16"/> values, they shall
		/// be placed at the end of this tag, and the KeyEntry will set
		/// TIFFTagLocation=GeoKeyDirectoryTag, with the Value_Offset pointing to the location of the
		/// value(s).
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public ushort[] GeoKeyDirectory
		{
			get
			{
				return GetTagArray<ushort>("GeoKeyDirectory");
			}
			set
			{
				SetTagValue("GeoKeyDirectory", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the GeoTIFF ModelPixelScaleTag.
		/// </summary>
		/// <remarks>
		/// The ModelPixelScaleTag tag may be used to specify the size of raster pixel spacing
		/// in the model space units, when the raster space can be embedded in the model space
		/// coordinate system without rotation, and consists of the following 3 values:
		/// <para/>
		/// ModelPixelScaleTag = (ScaleX, ScaleY, ScaleZ)
		/// <para/>
		/// where <i>ScaleX</i> and <i>ScaleY</i> give the horizontal and vertical spacing of
		/// raster pixels. The <i>ScaleZ</i> is primarily used to map the pixel value of a
		/// digital elevation model into the correct Z-scale, and so for most other purposes
		/// this value should be zero (since most model spaces are 2-D, with Z=0).
		/// <para/>
		/// A single tiepoint in the <see cref="ModelTiePoints"/> tag, together with this tag,
		/// completely determine the relationship between raster and model space; thus they
		/// comprise the two tags which Baseline GeoTIFF files most often will use to place a
		/// raster image into a "standard position" in model space.
		/// <para/>
		/// Like the <see cref="ModelTiePoints"/> tag, this tag information is independent of the
		/// XPosition, YPosition, Resolution and Orientation tags of the standard TIFF 6.0 spec.
		/// However, simple reversals of orientation between raster and model space
		/// (e.g. horizontal or vertical flips) may be indicated by reversal of sign in the
		/// corresponding component of the ModelPixelScaleTag. GeoTIFF compliant readers must
		/// honor this signreversal convention.
		/// <para/>
		/// This tag must not be used if the raster image requires rotation or shearing to place
		/// it into the standard model space. In such cases the transformation shall be defined
		/// with the more general <see cref="ModelTransformationMatrix"/>.
		/// <para/>
		/// <br/><b>Naming differences</b><para/>
		/// In the native FreeImage library and thus, in the FreeImage API documentation, this
		/// property's key is named <i>GeoPixelScale</i>. Since the GeoTIFF specification
		/// as well as Java's <c>EXIFTIFFTagSet</c> class call this tag
		/// <see cref="ModelPixelScale"/>, this property was renamed accordingly.
		/// However, when accessing this property's tag by its <see cref="MetadataTag"/> object,
		/// the native FreeImage tag key <i>GeoPixelScale</i> must be used.
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public double[] ModelPixelScale
		{
			get
			{
				return GetTagArray<double>("GeoPixelScale");
			}
			set
			{
				SetTagValue("GeoPixelScale", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the GeoTIFF GeoTiePointsTag.
		/// </summary>
		/// <remarks>
		/// The GeoTiePointsTag stores raster -> model tiepoint pairs in the order
		/// <para/>
		/// ModelTiePoints = (...,I,J,K, X,Y,Z...),
		/// <para/>
		/// where <i>(I,J,K)</i> is the point at location <i>(I,J)</i> in raster space with 
		/// pixel-value <i>K</i>, and <i>(X,Y,Z)</i> is a vector in model space. In most cases
		/// the model space is only two-dimensional, in which case both K and Z should be set
		/// to zero; this third dimension is provided in anticipation of future support for 3D
		/// digital elevation models and vertical coordinate systems.
		/// <para/>
		/// A raster image may be georeferenced simply by specifying its location, size and
		/// orientation in the model coordinate space M. This may be done by specifying the
		/// location of three of the four bounding corner points. However, tiepoints are only
		/// to be considered exact at the points specified; thus defining such a set of
		/// bounding tiepoints does not imply that the model space locations of the interior
		/// of the image may be exactly computed by a linear interpolation of these tiepoints.
		/// <para/>
		/// However, since the relationship between the Raster space and the model space will
		/// often be an exact, affine transformation, this relationship can be defined using
		/// one set of tiepoints and the <see cref="ModelPixelScale"/>, described below, which
		/// gives the vertical and horizontal raster grid cell size, specified in model units.
		/// <para/>
		/// If possible, the first tiepoint placed in this tag shall be the one establishing
		/// the location of the point (0,0) in raster space. However, if this is not possible
		/// (for example, if (0,0) is goes to a part of model space in which the projection is
		/// ill-defined), then there is no particular order in which the tiepoints need be
		/// listed.
		/// <para/>
		/// For orthorectification or mosaicking applications a large number of tiepoints may
		/// be specified on a mesh over the raster image. However, the definition of associated
		/// grid interpolation methods is not in the scope of the current GeoTIFF spec.
		/// <para/>
		/// <br/><b>Naming differences</b><para/>
		/// In the native FreeImage library and thus, in the FreeImage API documentation, this
		/// property's key is named <i>GeoTiePoints</i>. Since the GeoTIFF specification
		/// as well as Java's <c>EXIFTIFFTagSet</c> class call this tag
		/// <see cref="ModelTiePoints"/>, this property was renamed accordingly.
		/// However, when accessing this property's tag by its <see cref="MetadataTag"/> object,
		/// the native FreeImage tag key <i>GeoTiePoints</i> must be used.
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public double[] ModelTiePoints
		{
			get
			{
				return GetTagArray<double>("GeoTiePoints");
			}
			set
			{
				SetTagValue("GeoTiePoints", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the GeoTIFF ModelTransformationMatrixTag.
		/// </summary>
		/// <remarks>
		/// This tag may be used to specify the transformation matrix between the raster space
		/// (and its dependent pixel-value space) and the (possibly 3D) model space.
		/// <para/>
		/// <br/><b>Naming differences</b><para/>
		/// In the native FreeImage library and thus, in the FreeImage API documentation, this
		/// property's key is named <i>GeoTransformationMatrix</i>. Since the GeoTIFF specification
		/// as well as Java's <c>EXIFTIFFTagSet</c> class call this tag
		/// <see cref="ModelTransformationMatrix"/>, this property was renamed accordingly.
		/// However, when accessing this property's tag by its <see cref="MetadataTag"/> object,
		/// the native FreeImage tag key <i>GeoTransformationMatrix</i> must be used.
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public double[] ModelTransformationMatrix
		{
			get
			{
				return GetTagArray<double>("GeoTransformationMatrix");
			}
			set
			{
				SetTagValue("GeoTransformationMatrix", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the GeoTIFF IntergraphTransformationMatrixTag.
		/// </summary>
		/// <remarks>
		/// The IntergraphTransformationMatrixTag conflicts with an internal software implementation
		/// at Intergraph, and so its use is no longer encouraged. A GeoTIFF reader should look first
		/// for the new tag, and only if it is not found should it check for this older tag. If found,
		/// it should only consider it to be contain valid GeoTIFF matrix information if the tag-count
		/// is 16; the Intergraph version uses 17 values.
		/// <para/>
		/// <br/><b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public double[] IntergraphTransformationMatrix
		{
			get
			{
				return GetTagArray<double>("Intergraph TransformationMatrix");
			}
			set
			{
				SetTagValue("Intergraph TransformationMatrix", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the GeoTIFF JPLCartoIFDOffsetTag.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public uint? JPLCartoIFDOffset
		{
			get
			{
				return GetTagValue<uint>("JPL Carto IFD offset");
			}
			set
			{
				SetTagValue("JPL Carto IFD offset", value);
			}
		}
	}

	/// <summary>
	/// Represents a collection of all tags contained in the metadata model
	/// <see cref="FREE_IMAGE_MDMODEL.FIMD_IPTC"/>.
	/// </summary>
	public class MDM_IPTC : MetadataModel
	{
		/// <summary>
		/// Initializes a new instance of this class.
		/// </summary>
		/// <param name="dib">Handle to a FreeImage bitmap.</param>
		public MDM_IPTC(FIBITMAP dib) : base(dib) { }

		/// <summary>
		/// Retrieves the datamodel that this instance represents.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public override FREE_IMAGE_MDMODEL Model
		{
			get { return FREE_IMAGE_MDMODEL.FIMD_IPTC; }
		}

		/// <summary>
		/// Gets the Application Record Version.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public short? ApplicationRecordVersion
		{
			get
			{
				return GetTagValue<short>("ApplicationRecordVersion");
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Object Type Reference.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ObjectTypeReference
		{
			get
			{
				return GetTagText("ObjectTypeReference");
			}
			set
			{
				SetTagValue("ObjectTypeReference", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Object Attribute Reference.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ObjectAttributeReference
		{
			get
			{
				return GetTagText("ObjectAttributeReference");
			}
			set
			{
				SetTagValue("ObjectAttributeReference", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Object Name.
		/// This is also referred to as Title.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ObjectName
		{
			get
			{
				return GetTagText("ObjectName");
			}
			set
			{
				SetTagValue("ObjectName", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Edit Status.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string EditStatus
		{
			get
			{
				return GetTagText("EditStatus");
			}
			set
			{
				SetTagValue("EditStatus", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Editorial Update.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string EditorialUpdate
		{
			get
			{
				return GetTagText("EditorialUpdate");
			}
			set
			{
				SetTagValue("EditorialUpdate", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Urgency.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Urgency
		{
			get
			{
				return GetTagText("Urgency");
			}
			set
			{
				SetTagValue("Urgency", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Subject Reference.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string SubjectReference
		{
			get
			{
				return GetTagText("SubjectReference");
			}
			set
			{
				SetTagValue("SubjectReference", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Category.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Category
		{
			get
			{
				return GetTagText("Category");
			}
			set
			{
				SetTagValue("Category", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Supplemental Categories.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string SupplementalCategories
		{
			get
			{
				return GetTagText("SupplementalCategories");
			}
			set
			{
				SetTagValue("SupplementalCategories", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Fixture Identifier.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string FixtureIdentifier
		{
			get
			{
				return GetTagText("FixtureIdentifier");
			}
			set
			{
				SetTagValue("FixtureIdentifier", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Keywords.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Keywords
		{
			get
			{
				return GetTagText("Keywords");
			}
			set
			{
				SetTagValue("Keywords", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Content Location Code.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ContentLocationCode
		{
			get
			{
				return GetTagText("ContentLocationCode");
			}
			set
			{
				SetTagValue("ContentLocationCode", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Content Location Name.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ContentLocationName
		{
			get
			{
				return GetTagText("ContentLocationName");
			}
			set
			{
				SetTagValue("ContentLocationName", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Release Date.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ReleaseDate
		{
			get
			{
				return GetTagText("ReleaseDate");
			}
			set
			{
				SetTagValue("ReleaseDate", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Release Time.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ReleaseTime
		{
			get
			{
				return GetTagText("ReleaseTime");
			}
			set
			{
				SetTagValue("ReleaseTime", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Expiration Date.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ExpirationDate
		{
			get
			{
				return GetTagText("ExpirationDate");
			}
			set
			{
				SetTagValue("ExpirationDate", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Expiration Time.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ExpirationTime
		{
			get
			{
				return GetTagText("ExpirationTime");
			}
			set
			{
				SetTagValue("ExpirationTime", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Special Instructions.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string SpecialInstructions
		{
			get
			{
				return GetTagText("SpecialInstructions");
			}
			set
			{
				SetTagValue("SpecialInstructions", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Action Advised.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ActionAdvised
		{
			get
			{
				return GetTagText("ActionAdvised");
			}
			set
			{
				SetTagValue("ActionAdvised", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Reference Service.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ReferenceService
		{
			get
			{
				return GetTagText("ReferenceService");
			}
			set
			{
				SetTagValue("ReferenceService", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Reference Date.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ReferenceDate
		{
			get
			{
				return GetTagText("ReferenceDate");
			}
			set
			{
				SetTagValue("ReferenceDate", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Reference Number.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ReferenceNumber
		{
			get
			{
				return GetTagText("ReferenceNumber");
			}
			set
			{
				SetTagValue("ReferenceNumber", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Date Created.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string DateCreated
		{
			get
			{
				return GetTagText("DateCreated");
			}
			set
			{
				SetTagValue("DateCreated", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Time Created.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string TimeCreated
		{
			get
			{
				return GetTagText("TimeCreated");
			}
			set
			{
				SetTagValue("TimeCreated", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Digital Creation Date.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string DigitalCreationDate
		{
			get
			{
				return GetTagText("DigitalCreationDate");
			}
			set
			{
				SetTagValue("DigitalCreationDate", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Digital Creation Time.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string DigitalCreationTime
		{
			get
			{
				return GetTagText("DigitalCreationTime");
			}
			set
			{
				SetTagValue("DigitalCreationTime", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Originating Program.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string OriginatingProgram
		{
			get
			{
				return GetTagText("OriginatingProgram");
			}
			set
			{
				SetTagValue("OriginatingProgram", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Program Version.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ProgramVersion
		{
			get
			{
				return GetTagText("ProgramVersion");
			}
			set
			{
				SetTagValue("ProgramVersion", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Object Cycle.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ObjectCycle
		{
			get
			{
				return GetTagText("ObjectCycle");
			}
			set
			{
				SetTagValue("ObjectCycle", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag By Line.
		/// This is the author's name.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ByLine
		{
			get
			{
				return GetTagText("By-line");
			}
			set
			{
				SetTagValue("By-line", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag By Line Title.
		/// This is the author's position.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ByLineTitle
		{
			get
			{
				return GetTagText("By-lineTitle");
			}
			set
			{
				SetTagValue("By-lineTitle", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag City.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string City
		{
			get
			{
				return GetTagText("City");
			}
			set
			{
				SetTagValue("City", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Sub Location.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string SubLocation
		{
			get
			{
				return GetTagText("SubLocation");
			}
			set
			{
				SetTagValue("SubLocation", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Province State.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ProvinceState
		{
			get
			{
				return GetTagText("ProvinceState");
			}
			set
			{
				SetTagValue("ProvinceState", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Country Primary Location Code.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string CountryPrimaryLocationCode
		{
			get
			{
				return GetTagText("Country-PrimaryLocationCode");
			}
			set
			{
				SetTagValue("Country-PrimaryLocationCode", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Country Primary Location Name.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string CountryPrimaryLocationName
		{
			get
			{
				return GetTagText("Country-PrimaryLocationName");
			}
			set
			{
				SetTagValue("Country-PrimaryLocationName", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Original Transmission Reference.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string OriginalTransmissionReference
		{
			get
			{
				return GetTagText("OriginalTransmissionReference");
			}
			set
			{
				SetTagValue("OriginalTransmissionReference", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Headline.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Headline
		{
			get
			{
				return GetTagText("Headline");
			}
			set
			{
				SetTagValue("Headline", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Credit.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Credit
		{
			get
			{
				return GetTagText("Credit");
			}
			set
			{
				SetTagValue("Credit", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Source.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Source
		{
			get
			{
				return GetTagText("Source");
			}
			set
			{
				SetTagValue("Source", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Copyright Notice.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string CopyrightNotice
		{
			get
			{
				return GetTagText("CopyrightNotice");
			}
			set
			{
				SetTagValue("CopyrightNotice", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Contact.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Contact
		{
			get
			{
				return GetTagText("Contact");
			}
			set
			{
				SetTagValue("Contact", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Caption Abstract.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string CaptionAbstract
		{
			get
			{
				return GetTagText("CaptionAbstract");
			}
			set
			{
				SetTagValue("CaptionAbstract", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Writer Editor.
		/// This is also referred to as Caption Writer.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string WriterEditor
		{
			get
			{
				return GetTagText("WriterEditor");
			}
			set
			{
				SetTagValue("WriterEditor", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Rasterized Caption.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string RasterizedCaption
		{
			get
			{
				return GetTagText("RasterizedCaption");
			}
			set
			{
				SetTagValue("RasterizedCaption", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Image Type.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ImageType
		{
			get
			{
				return GetTagText("ImageType");
			}
			set
			{
				SetTagValue("ImageType", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Image Orientation.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ImageOrientation
		{
			get
			{
				return GetTagText("ImageOrientation");
			}
			set
			{
				SetTagValue("ImageOrientation", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Language Identifier.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string LanguageIdentifier
		{
			get
			{
				return GetTagText("LanguageIdentifier");
			}
			set
			{
				SetTagValue("LanguageIdentifier", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Audio Type.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string AudioType
		{
			get
			{
				return GetTagText("AudioType");
			}
			set
			{
				SetTagValue("AudioType", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Audio Sampling Rate.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string AudioSamplingRate
		{
			get
			{
				return GetTagText("AudioSamplingRate");
			}
			set
			{
				SetTagValue("AudioSamplingRate", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Audio Sampling Resolution.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string AudioSamplingResolution
		{
			get
			{
				return GetTagText("AudioSamplingResolution");
			}
			set
			{
				SetTagValue("AudioSamplingResolution", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Audio Duration.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string AudioDuration
		{
			get
			{
				return GetTagText("AudioDuration");
			}
			set
			{
				SetTagValue("AudioDuration", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Audio Outcue.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string AudioOutcue
		{
			get
			{
				return GetTagText("AudioOutcue");
			}
			set
			{
				SetTagValue("AudioOutcue", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Job I D.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string JobID
		{
			get
			{
				return GetTagText("JobID");
			}
			set
			{
				SetTagValue("JobID", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Master Document I D.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string MasterDocumentID
		{
			get
			{
				return GetTagText("MasterDocumentID");
			}
			set
			{
				SetTagValue("MasterDocumentID", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Short Document I D.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ShortDocumentID
		{
			get
			{
				return GetTagText("ShortDocumentID");
			}
			set
			{
				SetTagValue("ShortDocumentID", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Unique Document I D.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string UniqueDocumentID
		{
			get
			{
				return GetTagText("UniqueDocumentID");
			}
			set
			{
				SetTagValue("UniqueDocumentID", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Owner I D.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string OwnerID
		{
			get
			{
				return GetTagText("OwnerID");
			}
			set
			{
				SetTagValue("OwnerID", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Object Preview File Format.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ObjectPreviewFileFormat
		{
			get
			{
				return GetTagText("ObjectPreviewFileFormat");
			}
			set
			{
				SetTagValue("ObjectPreviewFileFormat", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Object Preview File Version.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ObjectPreviewFileVersion
		{
			get
			{
				return GetTagText("ObjectPreviewFileVersion");
			}
			set
			{
				SetTagValue("ObjectPreviewFileVersion", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Object Preview Data.
		/// This is also referred to as Audio Outcue.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ObjectPreviewData
		{
			get
			{
				return GetTagText("ObjectPreviewData");
			}
			set
			{
				SetTagValue("ObjectPreviewData", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Prefs.
		/// This is also referred to as photo-mechanic preferences.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Prefs
		{
			get
			{
				return GetTagText("Prefs");
			}
			set
			{
				SetTagValue("Prefs", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Classify State.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ClassifyState
		{
			get
			{
				return GetTagText("ClassifyState");
			}
			set
			{
				SetTagValue("ClassifyState", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Similarity Index.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string SimilarityIndex
		{
			get
			{
				return GetTagText("SimilarityIndex");
			}
			set
			{
				SetTagValue("SimilarityIndex", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Document Notes.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string DocumentNotes
		{
			get
			{
				return GetTagText("DocumentNotes");
			}
			set
			{
				SetTagValue("DocumentNotes", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Document History.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string DocumentHistory
		{
			get
			{
				return GetTagText("DocumentHistory");
			}
			set
			{
				SetTagValue("DocumentHistory", value);
			}
		}

		/// <summary>
		/// Gets or sets the value of the IPTC/NAA tag Exif Camera Info.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string ExifCameraInfo
		{
			get
			{
				return GetTagText("ExifCameraInfo");
			}
			set
			{
				SetTagValue("ExifCameraInfo", value);
			}
		}
	}

	/// <summary>
	/// Represents a collection of all tags contained in the metadata model
	/// <see cref="FREE_IMAGE_MDMODEL.FIMD_NODATA"/>.
	/// </summary>
	public class MDM_NODATA : MetadataModel
	{
		/// <summary>
		/// Initializes a new instance of this class.
		/// </summary>
		/// <param name="dib">Handle to a FreeImage bitmap.</param>
		public MDM_NODATA(FIBITMAP dib) : base(dib) { }

		/// <summary>
		/// Retrieves the datamodel that this instance represents.
		/// </summary>
		public override FREE_IMAGE_MDMODEL Model
		{
			get { return FREE_IMAGE_MDMODEL.FIMD_NODATA; }
		}
	}

	/// <summary>
	/// Represents a collection of all tags contained in the metadata model
	/// <see cref="FREE_IMAGE_MDMODEL.FIMD_XMP"/>.
	/// </summary>
	public class MDM_XMP : MetadataModel
	{
		/// <summary>
		/// Initializes a new instance of this class.
		/// </summary>
		/// <param name="dib">Handle to a FreeImage bitmap.</param>
		public MDM_XMP(FIBITMAP dib) : base(dib) { }

		/// <summary>
		/// Retrieves the datamodel that this instance represents.
		/// </summary>
		public override FREE_IMAGE_MDMODEL Model
		{
			get { return FREE_IMAGE_MDMODEL.FIMD_XMP; }
		}

		/// <summary>
		/// Gets or sets the XMP XML content.
		/// </summary>
		/// <remarks>
		/// <b>Handling of null values</b><para/>
		/// A null value indicates, that the corresponding metadata tag is not
		/// present in the metadata model.
		/// Setting this property's value to a non-null reference creates the
		/// metadata tag if necessary.
		/// Setting this property's value to a null reference deletes the
		/// metadata tag from the metadata model.
		/// </remarks>
		public string Xml
		{
			get
			{
				return GetTagText("XMLPacket");
			}
			set
			{
				SetTagValue("XMLPacket", value);
			}
		}

		/// <summary>
		/// Gets an <see cref="XmlReader"/> initialized to read the XMP XML content.
		/// Returns null, if the metadata tag <i>XMLPacket</i> is not present in
		/// this model.
		/// </summary>
		public XmlReader XmlReader
		{
			get
			{
				string xmlString = Xml;
				if (xmlString == null)
				{
					return null;
				}

				MemoryStream stream = new MemoryStream();
				StreamWriter writer = new StreamWriter(stream);
				writer.Write(xmlString);
				return XmlReader.Create(stream);
			}
		}
	}
}
